#include "PV.h"

PV::PV(  ){
         Dx=0;
         Dy=0;
};

PV::PV( float x , float y ){
         Dx=x;
         Dy=y;
};

float PV::getx(  ){
        return Dx;
};

float PV::gety(  ){
        return Dy;
};

void PV::setx( float x ){
        Dx=x;
};

void PV::sety( float y ){
        Dy=y;
};

void PV::setxy( float x , float y ){
        Dx=x;
        Dy=y;
};

float PV::module(  ){
        float dist = sqrt((Dx*Dx) + (Dy*Dy));
        return dist;
};

float PV::alpha(  ){
        float ang;

        if (Dx==0 && Dy <0) ang = 3*M_PI/2;
        if (Dx==0 && Dy >0) ang = M_PI/2;
        if (Dx > 0) ang = atan(Dy/Dx);
        if (Dx < 0) ang = atan(Dy/Dx) + M_PI;
        return ang;
};

void PV::inversion(  ){
         Dx=-Dx;
         Dy=-Dy;
};

PV PV::sumaPV(PV v2){
        PV v = PV(getx()+v2.getx(),gety()+v2.gety());
        return v;
};

PV PV::restaPV(PV v2){
        PV v = PV(getx()-v2.getx(),gety()-v2.gety());
        return v;
};

float PV::divisionPV(PV v2){
        float z  = module()/v2.module();
        return z;
};

PV PV::puntoMedio(PV v2){
        PV medio=PV((getx()+v2.getx())/2,(gety()+v2.gety())/2 );
        return medio;
};

void PV::escalacion(float escalar){
        Dx = Dx * escalar;
        Dy = Dy * escalar;
};

PV PV::normal (  ){
        float ang=alpha();
        ang=ang - (M_PI/2);
        return PV(cos(ang),sin(ang));
};

float PV::prodEscalar(PV v2){
        float alfa = alpha();
        float beta  = v2.alpha();
        float result= (module() * v2.module()) * cos(alfa-beta);

        return result;
};

void PV::rotaPV(PV centroRot, double ang){
        float  cx = centroRot.getx();
        float  cy = centroRot.gety();
        float  dx = (1.0-cos(ang))*cx + sin(ang)*cy;
        float  dy =-sin(ang)*cx + (1.0-cos(ang))*cy;
        float  x1 = Dx*cos(ang)-Dy*sin(ang)+dx;
        float  y1 = Dx*sin(ang)+Dy*cos(ang)+dy;
        Dx = x1;
        Dy = y1;
};

void PV::rotaPV(double ang) {
        float angOrig = alpha();
        float mod = module();
        Dx = mod*cos(angOrig+ang);
        Dy = mod*sin(angOrig+ang);
};

float PV::angle(){
        float ang = 0;

        if (Dx >= 0 && Dy >= 0) {ang = atan(Dy/Dx);}
        if (Dx <= 0 && Dy >= 0) {ang = atan(Dy/Dx) + M_PI/2;}
        if (Dx <= 0 && Dy <= 0) {ang = atan(Dy/Dx) + M_PI;}
        if (Dx >= 0 && Dy <= 0) {ang = atan(Dy/Dx) + 3*M_PI/2;}

        return ang;
};
